Internet Info 1994 March

home *** CD-ROM | disk | FTP | other *** search

/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / terms / kermit / a / msuibm.asm < prev next >

Wrap

Assembly Source File | 1993-07-12 | 72.4 KB | 2,100 lines

NAME msuibm ; File MSUIBM.ASM include mssdef.h ; Copyright (C) 1982,1993, Trustees of Columbia University in the ; City of New York. Permission is granted to any individual or ; institution to use, copy, or redistribute this software as long as ; it is not sold for profit and this copyright notice is retained. ; Keyboard translator, by Joe R. Doupnik, Dec 1986 ; with contributions from David L. Knoell. ; Edit history: ; 27 August 1992 version 3.13 ; 6 Sept 1991 version 3.11 ; Last edit 19 Feb 1993 ; 19 Feb 1993 Add volitle data swapping for Telnet sessions ; 1 July 1991 Add NumLock toggle from Ron Whittern. ; 7 Oct 1989 Add support for DEC LK250 keyboards, from Terry Kennedy. ; 2 August 1989 Allow verbs in definition strings [jrd] ; 21 Nov 1988 Version 2.32 ; 12 Nov 1988 Add verbs terminalr and terminals, unassigned to keys. ; 1 July 1988 Version 2.31 ; 20 May 1988 Add parser confirm requests below dfky13. [jrd] ; 10 March 1988 Add Holdscreen verb, holdscrn, for Terry Kennedy. [jrd] ; 27 Feb 1988 Add capability of stdin being a file rather than device. [jrd] ; 1 Jan 1988 version 2.30 public keybd, dfkey, shkey, msuinit, kbcodes public kbsusp, kbrest, kbhold ;** LK250 support for IBM-PCs public saveuoff, saveulen ; some definitions kbint equ 16h ; IBM, Bios keyboard interrupt shift equ 200h ; IBM, synonym for right or left shift control equ 400h ; IBM, synonym for control shift alt equ 800h ; IBM, synonym for alt shift enhanced equ 1000h ; IBM, enhanced keyboard code rgt_shift equ 1 ; IBM shift state bits lft_shift equ 2 ctl_shift equ 4 alt_shift equ 8 numlock equ 20h maxkeys equ 200 ; maximum number of key definitions maxstng equ 128 ; maximum number of multi-char strings stbuflen equ 1100 ; length of string buffer (bytes) verb equ 8000h ; dirlist flag: use verb action table strng equ 4000h ; dirlist flag: use string action table scan equ 100h ; keycode flag: code is scan not ascii braceop equ 7bh ; opening curly brace bracecl equ 7dh ; closing curly brace data segment extrn taklev:byte, comand:byte, flags:byte, keyboard:word extrn shkadr:word, stkadr:word, trans:byte, ttyact:byte ; system dependent references extrn vtemu:byte, holdscr:byte ; emulator data extrn vtmacname:word, vtmaclen:word ; external macro, in msyibm ;;; System Independent local storage crlf db cr,lf,'$' dfhelp1 db cr,lf,' Enter key',27h,'s identification as a character',cr,lf db ' or as its numerical equivalent \{b##} of ascii',cr,lf db ' or as its scan code \{b##}' db cr,lf,' or as SCAN followed by its scan code',cr,lf db ' where b is O for octal, X for hex, or D for decimal' db ' (default).',cr,lf,' Braces {} are optional.' db cr,lf,' Follow the identification with the new definition.' db cr,lf,' or CLEAR to restore initial key settings' db cr,lf,' or ON (default) for Bios i/o or OFF to use DOS i/o' db cr,lf,' or LK to use the DEC LK250 keyboard.$' ;IBM dfaskky db cr,lf,' Push key to be defined: $' dfaskdf db ' Enter new definition: ',0 ; asciiz for prompt verbbad db cr,lf,' No such verb',cr,lf,'$' strbad db cr,lf,' Not enough space for new string',cr,lf,'$' keyfull db cr,lf,' No more space to define keys',cr,lf,'$' dfkoops db cr,lf,' Oops! That is Kermit',27h,'s Escape Char.' db ' Translation is not permitted.',cr,lf,'$' shkmsg1 db cr,lf,'Push key to be shown (? shows all): $' shkmsg2 db ' decimal is defined as',cr,lf,'$' shkmsg3 db cr,lf,'... more, press a key to continue ...$' kwarnmsg db cr,lf,' Notice: this form of Set Key is obsolete$' ascmsg db ' Ascii char: $' scanmsg db ' Scan Code $' strngmsg db ' String: $' verbmsg db ' Verb: $' noxmsg db ' Self, no translation.$' fremsg db cr,lf,' Free space: $' kyfrdef db ' key and $' stfrdef db ' string definitions, $' stfrspc db ' string characters.',cr,lf,'$' even saveuoff label word ; per session save area start tranbuf db 132 dup (?) ; 132 byte translator work buffer ; translation tables keylist dw maxkeys dup (0) ; 16 bit keycodes, paralled by dirlist dirlist dw maxkeys dup (0) ; director {v+s} + {index | new char} sptable dw maxstng dup (0) ; list of asciiz string offsets stbuf dw stbuflen dup (0) ; buffer for strings strmax dw stbuf ; first free byte in stbuf stringcnt dw 0 ; qty of string chars to be processed stringptr dw 0 ; address of next string char nkeys dw 0 ; number of actively defined keys listptr dw 0 ; item number for keylist and dirlist keycode dw 0 ; ascii/scan code for key kbtemp dw 0 ; scratch storage for translator brace db 0 ; brace detected flag byte msutake db 0 ; if being run from take file or not verblen dw 0 ; length of user's verb (work temp) kwcnt dw 0 ; number of keywords (work temp) dosflg db 0 saveulen dw ($ - saveuoff) ; save area end oldform db 0 ; old form Set Key, if non-zero twelve dw 12d ;;; End System Independent Data Area ;;; System Dependent Data Area ; edit dfhelp2 to include nice list of verbs for this system. dfhelp2 db cr,lf,' Enter either \Kverb for a Kermit action verb',cr,lf db ' or a replacement string (single byte binary numbers are' db ' \{b##})',cr,lf,' or push Return to undefine a key, ^C to' db ' retain current definition.' db cr,lf,' Braces {} are optional, and strings maybe enclosed in' db ' them.',cr,lf,' Strings may not begin with the character' db ' combinations of \k or \{k',cr,lf db ' (start with a { brace instead).',cr,lf,lf db ' Verbs are as follows. Keys (arrows and keypad):',cr,lf db ' uparr, dnarr, lfarr, rtarr, kpminus, kpcoma, kpdot, kpenter,' db cr,lf db ' Gold (same as PF1), PF1, PF2, PF3, PF4, kp0, ... kp9' db cr,lf,' decFind, decInsert, decRemove, decSelect, decPrev,' db ' decNext' db cr,lf,' User Definable Keys decF6, ...decF14, decHelp,' db ' decDO, decF17, ...decF20' db cr,lf,' Compose (same as dgSPCL)' db cr,lf,' Data General dgC1, dgC2, dgC3, dgC4, dgF1, ...dgF15' db ', dgPoint, dgSPCL, dgNC' db cr,lf,' Kermit screen control and actions:',cr,lf db ' upscn, dnscn, homscn, endscn, upone, dnone (vertical ' db 'scrolling),' db cr,lf db ' lfpage, lfone, rtpage, rtone (horizontal scrolling)' db cr,lf db ' logoff, logon, termtype, reset, holdscrn, modeline, break,' db cr,lf db ' lbreak, nethold, nextsession, prtscn, dump, hangup, null' db ' (send one),' db cr,lf db ' DOS, help, ignore, status, exit' db cr,lf,'$' ; Aliaskey: keys having aliases - same ascii code but more than one ; scan code, as on auxillary keypads. Use just scan codes with these. ; Alternative use: force ascii keys to report out just scan codes. ; Table format: high byte = scan code, low byte = ascii code. ; Contents are machine dependent. aliaskey dw (14*scan)+bs ; Backspace key [hi=scan, lo=ascii] dw (55*scan)+'*' ; keypad asterisk dw (74*scan)+'-' ; keypad minus dw (78*scan)+'+' ; keypad plus dw (71*scan)+'7' ; keypad numeric area dw (72*scan)+'8' dw (73*scan)+'9' dw (75*scan)+'4' dw (76*scan)+'5' dw (77*scan)+'6' dw (79*scan)+'1' dw (80*scan)+'2' dw (81*scan)+'3' dw (82*scan)+'0' dw (83*scan)+'.' dw (83*scan)+',' ; German keypad had comma vs dot dw (15*scan)+tab dw (28*scan)+cr ; typewriter Enter key dw (57*scan)+' ' ; space bar aliaslen equ ($-aliaskey) shr 1 ; number of words in aliaskey table kverbs db 97 ; number of table entries below mkeyw 'uparr',uparrw ; independent of ordering and case! mkeyw 'dnarr',dnarrw ; mkeyw 'name',procedure entry point mkeyw 'lfarr',lfarr mkeyw 'rtarr',rtarr mkeyw 'Gold',pf1 mkeyw 'PF1',pf1 mkeyw 'PF2',pf2 mkeyw 'PF3',pf3 mkeyw 'PF4',pf4 mkeyw 'KP0',kp0 mkeyw 'KP1',kp1 mkeyw 'KP2',kp2 mkeyw 'KP3',kp3 mkeyw 'KP4',kp4 mkeyw 'KP5',kp5 mkeyw 'KP6',kp6 mkeyw 'KP7',kp7 mkeyw 'KP8',kp8 mkeyw 'KP9',kp9 mkeyw 'kpminus',kpminus mkeyw 'kpcoma',kpcoma mkeyw 'kpenter',kpenter mkeyw 'kpdot',kpdot mkeyw 'decF6',decf6 mkeyw 'decF7',decf7 mkeyw 'decF8',decf8 mkeyw 'decF9',decf9 mkeyw 'decF10',decf10 mkeyw 'decF11',decf11 mkeyw 'decF12',decf12 mkeyw 'decF13',decf13 mkeyw 'decF14',decf14 mkeyw 'decHelp',dechelp mkeyw 'decDo',decdo mkeyw 'decF17',decf17 mkeyw 'decF18',decf18 mkeyw 'decF19',decf19 mkeyw 'decF20',decf20 mkeyw 'decFind',decfind mkeyw 'decInsert',decinsert mkeyw 'decRemove',decremove mkeyw 'decSelect',decselect mkeyw 'decPrev',decprev mkeyw 'decNext',decnext mkeyw 'Compose',kbdcompose mkeyw 'termtype',vtans52 mkeyw 'reset',vtinit mkeyw 'holdscrn',khold mkeyw 'dnscn',dnwpg mkeyw 'upscn',upwpg mkeyw 'endscn',endwnd mkeyw 'homscn',homwnd mkeyw 'upone',upone mkeyw 'dnone',dnone mkeyw 'prtscn',trnprs mkeyw 'dump',dmpscn mkeyw 'modeline',trnmod mkeyw 'break',sendbr mkeyw 'lbreak',sendbl mkeyw 'hangup',chang mkeyw 'nethold',ubhold mkeyw 'nextsession',nextses mkeyw 'null',snull mkeyw 'logon',klogon mkeyw 'logoff',klogof mkeyw 'DOS',cdos mkeyw 'help',cquery mkeyw 'status',cstatus mkeyw 'exit',cquit mkeyw 'lfpage',lfpage mkeyw 'rtpage',rtpage mkeyw 'lfone',lfone mkeyw 'rtone',rtone mkeyw 'dgC1',dgkc1 mkeyw 'dgC2',dgkc2 mkeyw 'dgC3',dgkc3 mkeyw 'dgC4',dgkc4 mkeyw 'dgF1',dgkf1 mkeyw 'dgF2',dgkf2 mkeyw 'dgF3',dgkf3 mkeyw 'dgF4',dgkf4 mkeyw 'dgF5',dgkf5 mkeyw 'dgF6',dgkf6 mkeyw 'dgF7',dgkf7 mkeyw 'dgF8',dgkf8 mkeyw 'dgF9',dgkf9 mkeyw 'dgF10',dgkf10 mkeyw 'dgF11',dgkf11 mkeyw 'dgF12',dgkf12 mkeyw 'dgF13',dgkf13 mkeyw 'dgF14',dgkf14 mkeyw 'dgF15',dgkf15 mkeyw 'dgspcl',kbdcompose mkeyw 'dgpoint',dgpoint mkeyw 'dgnc',dgnckey mkeyw 'ignore',ignore_key ; Initialization data. kbdinlst equ this byte ; Kermit IBM initialization time keyboard setup mkeyw '\kgold',scan+59 ; F1 mkeyw 'definition',keycode mkeyw '\kpf2',scan+60 ; F2 mkeyw '\kpf3',scan+61 ; F3 mkeyw '\kpf4',scan+62 ; F4 mkeyw '\kkp0',scan+shift+90 ; VT100 keypad numeric area, SF7 mkeyw '\kkp1',scan+shift+86 ; SF3 mkeyw '\kkp2',scan+shift+87 ; SF4 mkeyw '\kkp3',scan+shift+88 ; SF5 mkeyw '\kkp4',scan+67 ; F9 mkeyw '\kkp5',scan+68 ; F10 mkeyw '\kkp6',scan+shift+84 ; SF1 mkeyw '\kkp7',scan+63 ; F5 mkeyw '\kkp8',scan+64 ; F6 mkeyw '\kkp9',scan+65 ; F7 mkeyw '\kkpenter',scan+shift+89 ; SF6 mkeyw '\kkpcoma',scan+shift+85 ; SF2 mkeyw '\kkpminus',scan+66 ; F8 mkeyw '\kkpdot',scan+shift+91 ; SF8 mkeyw '\kuparr',scan+72 ; VT100 cursor keys (arrows) mkeyw '\kdnarr',scan+80 mkeyw '\klfarr',scan+75 mkeyw '\krtarr',scan+77 mkeyw '\kupscn',scan+73 ; PgUp Kermit screen roll back keys mkeyw '\kdnscn',scan+81 ; PgDn mkeyw '\khomscn',scan+71 ; Home mkeyw '\kendscn',scan+79 ; End mkeyw '\kupone',scan+control+132 ; Ctrl PgUp one line scrolls mkeyw '\kdnone',scan+control+118 ; Ctrl PgDn mkeyw '\kuparr',scan+enhanced+72 ; Enhanced kbd duplicate keys mkeyw '\kdnarr',scan+enhanced+80 mkeyw '\klfarr',scan+enhanced+75 mkeyw '\krtarr',scan+enhanced+77 mkeyw '\kupscn',scan+enhanced+73 ; PgUp Kermit screen roll back keys mkeyw '\kdnscn',scan+enhanced+81 ; PgDn mkeyw '\khomscn',scan+enhanced+71 ; Home mkeyw '\kendscn',scan+enhanced+79 ; End mkeyw '\kupone',scan+control+enhanced+132 ;Ctrl PgUp one line scroll mkeyw '\kdnone',scan+control+enhanced+118 ; Ctrl PgDn mkeyw '\kmodeline',scan+74 ; Kermit toggle mode line Keypad - mkeyw '\ktermtype',scan+alt+130 ; Kermit toggle terminal type Alt - mkeyw '\kreset',scan+alt+131 ; Kermit reset terminal Alt = mkeyw '\kprtscn',scan+control+114 ; Kermit toggle prn scrn Ctrl * mkeyw '\kdump',scan+control+117 ; Kermit Dump Screen Ctrl End mkeyw '*',scan+55 ; keypad asterisk mkeyw '*',scan+enhanced+55 ; Enhanced kbd keypad asterisk mkeyw '+',scan+78 ; keypad plus mkeyw '.',scan+shift+83 ; IBM numeric keypad mkeyw '0',scan+shift+82 mkeyw '1',scan+shift+79 mkeyw '2',scan+shift+80 mkeyw '3',scan+shift+81 mkeyw '4',scan+shift+75 mkeyw '5',scan+shift+76 mkeyw '6',scan+shift+77 mkeyw '7',scan+shift+71 mkeyw '8',scan+shift+72 mkeyw '9',scan+shift+73 mkeyw ' ',scan+57 ; space bar yields space mkeyw ' ',scan+shift+57 ; Shift + space bar mkeyw '\0',scan+control+57 ; Control-space bar yields nul mkeyw '\0',scan+control+shift+57; Shift Control-space bar mkeyw tab,scan+15 ; regular Tab key, made special mkeyw cr,scan+28 ; typewriter Enter key mkeyw cr,scan+enhanced+cr ; Enhanced kbd grey Enter key mkeyw lf,scan+enhanced+control+lf ; Enhanced grey Control Enter mkeyw '/',scan+enhanced+'/' ; Enhanced kbd grey foward slash mkeyw '\0',scan+control+3 ; Control at-sign sends null mkeyw '\0',scan+control+shift+3 ; Control Shift at-sign sends null mkeyw '\x7f',scan+83 ; Del key sends DEL mkeyw '\x7f',scan+enhanced+83 ; Enhanced duplicate DEL sends DEL mkeyw '\x7f',scan+14 ; Backspace key sends DEL mkeyw '\kexit',scan+alt+45 ; Exit connect mode Alt X mkeyw '\kstatus',scan+alt+31 ; Connect mode status Alt S mkeyw '\kbreak',scan+alt+48 ; Send a Break Alt B mkeyw '\kbreak',scan+control+0; Control-Break sends a Break too mkeyw '\khelp',scan+alt+35 ; Connect mode drop down menu Alt H mkeyw '\knextsession',scan+alt+49 ; nextses is Alt N mkeyw '\knethold',scan+alt+44 ; ALT Z is nethold dw 0 ; end of table marker ;** LK250 support begin kb250lst equ this byte ; Extensions for DEC LK250 keyboard mkeyw escape,scan+104 ; Compose maps to ESC mkeyw '\x7f',scan+14 ; Backspace key sends DEL mkeyw bs,scan+shift+14 ; Shift-Backspace key sends BS mkeyw cr,scan+28 ; Return key sends CR mkeyw lf,scan+shift+28 ; Shift-Return sends LF mkeyw tab,scan+15 ; Tab sends TAB ; the top-row function keys mkeyw '\kholdscrn',scan+59 ; DEC Hold mkeyw '\kprtscn',scan+60 ; DEC Print Screen ;;;; mkeyw '{\{kstatus}\{kexit}}',scan+61 ; DEC Set-Up mkeyw '\kbreak',scan+63 ; DEC Break mkeyw '\kdecF6',scan+64 ; DEC F6 mkeyw '\kdecF7',scan+65 ; DEC F7 mkeyw '\kdecF8',scan+66 ; DEC F8 mkeyw '\kdecF9',scan+67 ; DEC F9 mkeyw '\kdecF10',scan+68 ; DEC F10 mkeyw '\kdecF11',scan+95 ; DEC F11 mkeyw '\kdecF12',scan+96 ; DEC F12 mkeyw '\kdecF13',scan+97 ; DEC F13 mkeyw '\kdecF14',scan+98 ; DEC F14 mkeyw '\kdecHelp',scan+99 ; DEC Help mkeyw '\kdecDo',scan+100 ; DEC DO mkeyw '\kdecF17',scan+101 ; DEC F17 mkeyw '\kdecF18',scan+102 ; DEC F18 mkeyw '\kdecF19',scan+103 ; DEC F19 mkeyw '\kdecF20',scan+84 ; DEC F20 ; the cursor/select cluster mkeyw '\kdecFind',scan+85 ; DEC Find mkeyw '\kdecInsert',scan+86 ; DEC Insert Here mkeyw '\kdecRemove',scan+87 ; DEC Remove mkeyw '\kdecSelect',scan+88 ; DEC Select mkeyw '\kdecPrev',scan+89 ; DEC Prev mkeyw '\kdecNext',scan+90 ; DEC Next mkeyw '\kuparr',scan+91 ; up arrow mkeyw '\klfarr',scan+92 ; left arrow mkeyw '\krtarr',scan+93 ; right arrow mkeyw '\kdnarr',scan+94 ; down arrow ; the DEC editing keypad mkeyw '\kgold',scan+106 ; F1 mkeyw '\kpf2',scan+107 ; F2 mkeyw '\kpf3',scan+108 ; F3 mkeyw '\kpf4',scan+109 ; F4 mkeyw '\kkp7',scan+shift+71 ; KP7 mkeyw '\kkp8',scan+shift+72 ; KP8 mkeyw '\kkp9',scan+shift+73 ; KP9 mkeyw '\kkpminus',scan+74 ; KP- mkeyw '\kkp4',scan+shift+75 ; KP4 mkeyw '\kkp5',scan+shift+76 ; KP5 mkeyw '\kkp6',scan+shift+77 ; KP6 mkeyw '\kkpcoma',scan+78 ; KP, mkeyw '\kkp1',scan+shift+79 ; KP1 mkeyw '\kkp2',scan+shift+80 ; KP2 mkeyw '\kkp3',scan+shift+81 ; KP3 mkeyw '\kkpenter',scan+105 ; keypad enter mkeyw '\kkpenter',scan+shift+105 ; keypad enter mkeyw '\kkp0',scan+shift+82 ; KP0 mkeyw '\kkpdot',scan+shift+83 ; KP. ; some useful Kermit keys mkeyw '\kupscn',scan+alt+89 ; PgUp Kermit screen roll back keys mkeyw '\kdnscn',scan+alt+90 ; PgDn mkeyw '\khomscn',scan+alt+85 ; Home mkeyw '\kendscn',scan+alt+88 ; End mkeyw '\kupone',scan+control+89 ; Ctrl PgUp one line scrolls mkeyw '\kdnone',scan+control+90 ; Ctrl PgDn mkeyw '\kexit',scan+alt+45 ; Exit connect mode Alt X mkeyw '\kstatus',scan+alt+31 ; Connect mode status Alt S mkeyw '\kbreak',scan+alt+48 ; Send a Break Alt B mkeyw '\kbreak',scan+control+108 ; Control-Break sends a Break too mkeyw '\khelp',scan+alt+35 ; Connect mode drop down menu Alt H mkeyw '\ktermtype',scan+alt+130 ; Kermit toggle terminal type Alt - mkeyw '\kreset',scan+alt+131 ; Kermit reset terminal Alt = mkeyw '\kprtscn',scan+control+109 ; Kermit toggle prn scrn Ctrl * mkeyw '\kdump',scan+control+88 ; Kermit Dump Screen Ctrl End dw 0 ; end of table marker got250 db 0 ;** LK250 present if non-zero kbd250 db 0 ; enable use of LK250 if non-zero lk250msg db cr,lf,'?LK250 keyboard external driver is not active.$' ;** LK250 support end kbcodes dw 80h ; keyboard read codes, 80h=not inited data ends ; Documentation ;Translating a key: ; The translator is called to obtain keyboard input; it sends characters to ; the serial port through standard controlled echo procedures or invokes ; named procedures. It returns carry clear when its operation is completed ; for normal actions and carry set when Connect mode must be exited. When ; Connect mode is exited the just read char should be passed in Kbdflg ; to msster.asm for invoking actions such as Status, send a break, ; quit connect mode; system dependent procedure Term is responsible for this. ; ; Principal procedures are - ; msuinit Initializes keyboard translator in this file when ; Kermit first begins. Installs dfkey and shkey as the ; procedures used for Set Key and Show Key. Sys Indep. ; Called from msx or msy init procs. System Independent. ; keybd Performs the translation, outputs chars to the serial ; port or invokes a Kermit action routine. Sys Indep. ; dfkey Defines a key's translation. Reads command line ; via Kermit's command parser comnd. System Independent. ; shkey Shows translation of a key. Requests user to push ; selected key. System Independent. ; ; kbdinit optional. Initializes the translation tables when ; Kermit starts up. Called by msuinit. System Dependent. ; getkey Performs the keyboard read and returns results in ; a standardized system independent format. Sys Depend. ; postkey called by active translator after obtaining a keycode. ; Used to provide extra local actions (keyclick) only ; in Connect mode (not during Set/Show key commands). ; Called by keybd. System dependent. ; Supporting system independent procedures are - ; shkfre (show string free space), tstkeyw (finds user's keyword in the verb ; table), insertst (insert string in buffer), remstr (delete string in buffer). ; ; System dependent procedure Getkey reads a keycode (usually via a Bios ; call). On IBM compatible machines this yields <ah=scan code, al=ascii> ; for ordinary keys, or <ah=scan code, al=0> for special keys such as F1, ; or <ah=0, al=###> when Alt### is used. ; For any system, the canonical output form is the key's code in Keycode. ; Place the ascii code (or scan code if none) in byte Keycode and ancillary ; info (shift states plus marker bit for scan codes) in byte Keycode + 1. ; ; Table Aliaskey is a list of scan code/ascii codes for keys which appear ; more than once on a keyboard. This list is examined to distinguish such ; aliased keys (those on an auxillary keypad) from an ordinary ascii key, ; and the aliased key is then referenced by its scan code rather than by ; the ordinary ascii code. Aliaskey is machine and keyboard dependent. ; ; Procedure Keybd calls Getkey for the Keycode, checks list of translatable ; keys Keylist, and then either sends an ascii string (one or more characters) ; or invokes a Kermit action verb. List Dirlist indicates what kind of ; translation to do. Keybd is system independent but may contain system ; dependent special actions such as echoing keyclicks. Keybd calls system ; dependent procedure Postkey just after calling getkey so local actions ; such as keyclicks can be activated only during Connect mode operations. ; ; Keylist is a packed but unordered list of 16 bit keycodes which need ; translation. The lower order byte holds a key code (ascii char or scan code) ; while the high byte holds a scan code marker bit (0 if ascii code in low ; byte) plus any ancillary keyboard information such as Control/Shift/Alt/Meta ; keys being held down; these are of use in Show Key presentations. ; Dirlist parallels Keylist to provide the kind of translation, verb or ; string, in the two highest bits with the other bits holding either ; a single new replacement character or the item number in lists of verbs ; or strings. If neither verb nor strng type bits are set in a dirlist ; word then the translation is a single new character held in the lower ; eight bits of that dirlist word. ; ; The number of key translations is assembly constant Maxkeys (def 128). ; The maximum number of strings is assembly constant Maxstngs (def 64). ; The maximum number of verbs is 256 and is set by building table Kverbs. ; ; For verbs, use the Item number from the Director table Dirlist to select ; a procedure offset from the structured list Kverbs and jump to that offset. ; Most verb procedures return carry clear to stay within Connect mode. ; Verbs requiring exiting Connect mode return carry set and may set byte ; Kbdflg to a char code which will be read by msster.asm for activating a ; transient Kermit action such as send a break (Kbdflg = 'b'). ; Kbdflg is stored in msster.asm (as zero initially, meaning ignore it). ; Action verb procedures are normally located in a system dependent file. ; ; For multi-char strings, use Item number from Director table Dirlist to ; select a pointer to a string. The list of string pointers is Sptable ; (string pointer table) which holds the offset in the data segment of the ; strings stored in buffer Stbuf. In stbuf strings are held as: one byte of ; length of following text and then the text itself (permits embedded nulls). ; Use Chrout to send each string character, and finally return from Keybd ; with carry clear. ; ; For single character replacements obtain the new character from the lower ; order byte of Director table Dirlist. If the character is Kermit's present ; escape character return from Keybd carry set to leave connect mode. ; Otherwise, send the character via Chrout and return from Keybd carry clear. ; Keylist table format: ; 7 bits 1 bit 8 bits ; +----------+----+------------+ scan bit = 1 if key's code is non-ascii ; | aux info |scan| key's code | aux info = system dependent, used only to ; +----------+----+------------+ help identify key ; ; Dirlist table format v s meaning ; 1 1 14 bits 0 0 copy out one byte translation ; +---+---+--------------------+ 1 0 copy out multi-char string number Item ; | v | s | item # or new char | 0 1 do action verb number Item ; +---+---+--------------------+ 1 1 (not used) ; ; Table kverbs is organized by macro mkeyw as - ; kverbs db number of table entries ; (each entry is in the form below:) ; dw number of bytes in verbname ; db 'verbname' variable length ; dw value offset of procedure ; ; ; Dfkey defines a key to be itself (undefines it) or a single replacement ; character or a character string or a Kermit action verb. Dfkey requires ; a command line so that it may be invoked by Take files but can be forced ; to prompt an interactive user to push a key. Syntax is discussed below. ; Note that redefined keys have their old definitions cleared so that ; old string space is reclaimed automatically. ; ; Shkey displays a key's definition and the user is asked to push the ; selected key. The free space for strings is always shown afterward. See ; below for syntax. ; ; Kbdinit is an optional routine called when Kermit starts up. It fills in ; the translation tables with desirable default values to save having to ; use long mskermit.ini files. The default values are stored in a structured ; table similar to (but not the same as) Dfkey's command lines; the keycode ; values are preset by hand to 16 bit numbers. ;Defining a key: ; Command is SET KEY <key ident><whitespace><definition> ; ; <key ident> is ; a single ordinary ascii char or ; the numerical equivalent of an ascii char or ; a Scan Code written as a number or ; keyword SCAN followed by a number. ; ? Displays help message. ; Numbers and Binary codes are of the form ; \123 a decimal number ; \o456 an octal number base letters o, d, x can be ; \d213 a decimal number upper or lower case ; \x0d a hex number ; \{b###} braces around above material following slash. ; ; <whitespace> is one or more spaces and or tabs. ; ; <definition> is ; missing altogether which "undefines" a key. ; \Kverb for a Kermit action verb; upper or lower case K is ok ; \{Kverb} ditto. Verb is the name of an action verb. ; text a string with allowed embedded whitespace and embedded ; binary chars as above. This kind of string may not ; commence with sequences \K or \{K; use braces below. ; {text} string confined to material within but excluding ; the braces. Note, where the number of opening braces ; exceeds the number of closing braces the end of line ; terminates the string: {ab{}{{c}d ==> ab{}{{c}d ; but {ab}{{c}d ==> ab. ; ? Displays help message and lists all action verbs. ; ; If Set Key is given interactively, as opposed to within a Take ; file, the system will prompt for inputs if none is on the command ; line. The response to Push key to be defined cannot be edited. ; ; Text which reduces to a single replacement character is put into a ; table separate from the multi-character strings (maxstng of these). ; A key may be translated into any single 8 bit code. ; ; Comments can follow a Kermit action verb or a braced string; no ; semicolon is required since all are stripped out by the Take file ; reader before the defining text is seen by SET KEY. ; ; The current Kermit escape character cannot be translated without ; subtrafuge. ; ; Examples: ; Set Key q z ; makes key q send character z ; Set Key \7 \27[0m ; makes key Control G send the four byte ; string ESC [ 0 m ; Set Key q ; undefines key q so it sends itself (q) again. ; Set Key \2349 \kexit ; defines IBM Alt-X to invoke the leave connect ; mode verb "exit" (Kermit's escape-char ^] C). ; Set Key \x0c Login \{x0d}myname\{x0d}mypass\x0d ; defines Control L to send the string ; Login <cr>myname<cr>mypass<cr> ; ; Alternative Set Key syntax for backward compatibility with previous versions ; The same forms as above except the key identification number must ; be decimal and must Not have a leading backslash. Example: ; Set Key Scan 59 This is the F1 key ; ; If the definition is omitted it may be placed on the following line; ; if that line is also empty the key is undefined (defined as Self). ; A warning message about obsolete syntax will be given followed by ; the key's modern numerical value and new definition. Only "special" ; keys (those not producing ascii codes) are compatible with this ; translator. ; ;Showing a key: ; Command is SHOW KEY <cr> ; System prompts user to press a key and shows the definition plus the ; free space for strings. Query response results in showing all definitions. ; End Documentation code1 segment extrn vclick:near, udkclear:near ; in msyibm extrn xltkey:far ; in mszibm fudkclear proc far call udkclear ret fudkclear endp fvclick proc far call vclick ret fvclick endp code1 ends code segment ; system independent external items extrn comnd:near, prompt:near, iseof:near ; in msscmd extrn strlen:near, prtscr:near ; in mssfil extrn cnvlin:near, katoi:near, decout:near ; in msster ; system dependent external items extrn beep:near, khold:near, ubhold:near, nextses:near ; these are system dependent action verbs, in msxibm & msyibm extrn uparrw:near, dnarrw:near, rtarr:near, lfarr:near extrn pf1:near, pf2:near, pf3:near, pf4:near, kp0:near, kp1:near extrn kp2:near, kp3:near, kp4:near, kp5:near, kp6:near, kp7:near extrn kp8:near, kp9:near, kpminus:near, kpcoma:near, kpenter:near extrn kpdot:near, decf6:near, decf7:near, decf8:near, decf9:near extrn decf10:near, decf11:near, decf12:near, decf13:near extrn decf14:near, dechelp:near, decdo:near, decf17:near extrn decf18:near, decf19:near, decf20:near extrn decfind:near, decinsert:near, decremove:near extrn decselect:near, decprev:near, decnext:near, ignore_key:near extrn chrout:near, cstatus:near, cquit:near, cquery:near extrn vtans52:near, vtinit:near, dnwpg:near, upwpg:near extrn endwnd:near, homwnd:near, upone:near, dnone:near, trnprs:near extrn trnmod:near, sendbr:near, sendbl:near, dmpscn:near, snull:near extrn chang:near, klogon:near, klogof:near, cdos:near extrn lfpage:near, rtpage:near, lfone:near, rtone:near extrn extmacro:near extrn dgkc1:near,dgkc2:near,dgkc3:near,dgkc4:near,dgkf1:near extrn dgkf2:near,dgkf3:near,dgkf4:near,dgkf5:near,dgkf6:near extrn dgkf7:near,dgkf8:near,dgkf9:near,dgkf10:near,dgkf11:near extrn dgkf12:near,dgkf13:near,dgkf14:near,dgkf15:near extrn dgpoint:near, dgnckey:near, kbdcompose:near assume cs:code, ds:data, es:data ; Begin system independent Keyboard Translator code ; MSUINIT performs Kermit startup initialization for this file. ; Note, shkadr and stkadr are pointers tested by Set/Show Key calls. If they ; are not initialized here then the older Set/Show Key procedures are called. MSUINIT PROC NEAR ; call from msx/msy init code call kbdinit ; optional: init translator tables mov shkadr,offset shkey ; declare keyboard translator present mov stkadr,offset dfkey ; via Show and Set Key proc addresses ret MSUINIT ENDP ; Call Keybd to read a keyboard char (just returns carry clear if none) and ; 1) send the replacement string (or original char if not translated) ; out the serial port, or ; 2) execute a Kermit action verb. ; Returns carry set if Connect mode is to be exited, else carry clear. ; Modifies registers ax and bx. KEYBD PROC NEAR ; active translator mov ttyact,1 ; doing single char output cmp stringcnt,0 ; any leftover string chars? je keybd0 ; e = no jmp keyst2 ; yes, finish string keybd0: call getkey ; read keyboard jnc keybd1 ; nc = data available jmp keybdx ; else just return carry clear keybd1: call postkey ; call system dependent post processor cmp nkeys,0 ; is number of keys defined = 0? jz keybd3 ; z = none defined push di ; search keylist for this keycode push cx ; save some registers push es mov di,offset keylist ; list of defined keycode words mov ax,keycode ; present keycode mov cx,nkeys ; number of words to examine push ds pop es ; make es:di point to data segment cld repne scasw ; find keycode in list pop es ; restore regs pop cx je keybd1b ; e = found, work with present di pop di ; restore original di test keycode,scan ; is this a scan code? jz keybd3 ; z = no, it's ascii, use al as char call beep ; say key is a dead one clc ret ; and exit with no action keybd1b:sub di,2 ; correct for auto increment sub di,offset keylist ; subtract start of list ==> listptr mov ax,dirlist[di] ; ax = contents of director word pop di ; restore original di ; dispatch on Director code test ax,verb ; verb only? jnz keyvb ; e = yes test ax,strng ; multi-char string only? jnz keyst ; e = yes, else single char & no xlat. ; ; do single CHAR output (char in al) keybd3: cmp al,trans.escchr ; Kermit's escape char? je keybd3a ; e = yes, handle separately call xltkey ; do character set translation call chrout ; transmit the char clc ; return success ret keybd3a:stc ; set carry for jump to Quit ret keyvb: and ax,not(verb+strng) ; VERB (ax=index, remove type bits) mov bx,offset kverbs ; start of verb table cmp al,byte ptr [bx] ; index > number of entries? jae keybdx ; ae = illegal, indices start at 0 inc bx ; bx points to first entry push cx ; save reg mov cx,ax ; save the index in cx inc cx ; counter, indices start at 0 keyvb1: mov ax,[bx] ; cnt value add ax,4 ; skip text and value word add bx,ax ; look at next slot loop keyvb1 ; walk to correct slot sub bx,2 ; backup to value field pop cx ; restore reg mov bx,[bx] ; get value field of this slot or bx,bx ; jump address defined? jz keybdx ; z = no, skip the action jmp bx ; perform the function keyst: and ax,not(verb+strng) ; STRING (ax=index, remove type bits) shl ax,1 ; convert to word index push si ; save working reg mov si,ax ; word subscript in table mov si,sptable[si] ; memory offset of selected string xor cx,cx ; init string length to null or si,si ; is there a string pointer present? jz keyst1 ; z = no, skip operation cld ; scan forward mov cx,[si] ; get string length add si,2 keyst1: mov stringcnt,cx mov stringptr,si pop si jcxz keybdx ; z = null length keyst2: push si mov si,stringptr ; pointer to next string char cld lodsb ; get new string char into al pop si dec stringcnt ; string chars remaining inc stringptr call keysv ; scan for embedded verbs jc keyst4 ; c = not found, al has string char jmp bx ; perform the verb (bx = address) keyst4: call xltkey ; do character set translation cmp stringcnt,0 ; last character? je keyst5 ; e = yes, stop grouping for nets mov ttyact,0 ; group output for networks keyst5: jmp chrout ; send out the char in al keybdx: clc ; return success (nothing to do) ret KEYBD ENDP ; Scan for keyboard verbs embedded in outgoing string. If found update ; string pointer and count to just beyond the verb and return action routine ; address in bx with carry clear. If failure return carry set and no change. ; Can invoke external procedure EXTMACRO if the verb is not known here. keysv proc near push ax push si push di cmp al,'\' ; escape? jne keysv7 ; ne = no mov cx,stringcnt ; chars remaining mov si,stringptr ; address of next char to read mov brace,0 ; assume not using braces cmp byte ptr [si],braceop ; starts with \{? jne keysv1 ; ne = no inc si ; skip the opening brace dec cx mov brace,bracecl ; expect closing brace keysv1: cmp byte ptr [si],'K' ; starts with \{K or \K? je keysv2 ; e = yes cmp byte ptr [si],'k' ; starts as \{k or \k? jne keysv7 ; ne = no, then it's a string keysv2: inc si ; yes, skip the K too dec cx mov di,offset tranbuf ; copy verb name to this work buffer xor ax,ax mov [di],ax ; init the buffer to empty keysv3: cld jcxz keysv4 ; z = no more string chars lodsb ; scan til closing brace or w/s or end dec cx cmp al,brace ; closing brace? je keysv4 ; e = yes cmp al,spc ; white space or control char? jbe keysv3 ; be = yes mov [di],ax ; copy to tranbuf and terminate inc di jmp short keysv3 keysv4: push si ; save input reading position mov si,offset tranbuf ; where verb starts (needs si) call tstkeyw ; find keyword, bx = action routine pop si jnc keysv4a ; nc = found the verb call keysv8 ; invoke EXTMACRO worker for unknown jc keysv7 ; carry = no verb to operate upon keysv4a:cmp brace,0 ; need to end on a brace? je keysv6 ; e = no dec si ; break position inc cx cld keysv5: jcxz keysv6 ; z = no more string characters lodsb ; read string char dec cx cmp al,brace ; the brace? jne keysv5 ; ne = no, repeat until it is found keysv6: mov stringptr,si ; where we finished+1 mov stringcnt,cx ; new count of remaining chars pop di pop si ; original si, starting place pop ax ; original ax clc ret keysv7: pop di ; verb not found pop si pop ax stc ret ; Worker. Unknown verb name as string {\kverb} or {\k{verb}}. Use EXTMACRO ; procedure (in msyibm typically), point to verb name with vtmacname, length ; of it in byte vtmaclen, address of EXTMACRO to BX. Upper case the verb. ; Enter with tranbuf holding the verb, asciiz, without \K and braces. ; Returns BX set to EXTMACRO proc, vtmacname pointing to verb (uppercased) ; and vtmaclen holding the length of verb. keysv8: mov bx,offset extmacro ; use this external macro pointer mov vtmacname,offset tranbuf; select extmacro procedure address mov dx,offset tranbuf ; point to name for extmacro push cx call strlen ; get its length mov vtmaclen,cx ; length for extmacro jcxz keysv11 ; z = none push si ; convert verb name to upper case mov si,dx ; verb, without leading \K stuff cld keysv9: lodsb ; read a name byte cmp al,'a' ; before lower case? jb keysv10 ; e = yes cmp al,'z' ; above lower case? ja keysv10 ; a = yes and al,not 20h ; convert to upper case mov [si-1],al ; put it back keysv10:loop keysv9 ; do all bytes, asciiz pop si pop cx clc ; carry clear = ready to execute ret keysv11:stc ; carry set = no verb, do nothing pop cx ret keysv endp ; SET KEY - define a key (procedure dfkey) ; SET KEY <key ident><whitespace><new meaning> ; Call from Kermit level. Returns carry set if failure. ; DFKEY PROC NEAR ; define a key as a verb or a string mov keycode,0 ; clear keycode mov oldform,0 ; say no old form Set Key yet or byte ptr kbcodes,80h ; say kbcodes not-initiated mov dx,offset tranbuf ; our work space mov word ptr tranbuf,0 ; insert terminator mov bx,offset dfhelp1 ; first help message mov ah,cmword ; parse a word call comnd ; get key code or original ascii char mov cl,taklev ; reading from Take file mov msutake,cl ; save here or ax,ax ; any text given? jnz dfkey12 ; nz = yes, so don't consider prompts ; interactive key request cmp taklev,0 ; in a Take file? je dfkey10 ; e = no, prompt for keystroke jmp dfkey0 ; else say bad syntax dfkey10:mov ah,prstr mov dx,offset dfaskky ; ask for key to be pressed int dos dfkey11:call getkey ; read key ident from keyboard jc dfkey11 ; c = no response, wait for keystroke mov ah,prstr ; display cr/lf mov dx,offset crlf int dos call shkey0 ; show current definition (in SHKEY) jmp dfkey1e ; prompt for and process definition dfkey12: ; Look for word SCAN and ignore it mov dx,word ptr tranbuf ; get first two characters or dx,2020h ; map upper to lower case cmp dx,'cs' ; first two letters of word "scan"? je dfkey ; e = yes, skip the word cmp dx,'lc' ; first two letters of word "clear"? je dfkey15 ; e = yes, reinit keyboard [2.31] cmp dx,'fo' ; first two letters of "off" je dfkey13 ; e = yes, use DOS keyboard calls cmp dx,'no' ; first two letters of "on" je dfkey13 ; e = yes, use standard kbd calls cmp dx,'kl' ; first two letters of "lk" (LK250)? je dfkey13 ; e = yes cmp ax,1 ; number of characters received jbe dfkey12a ; be = stay here jmp dfkey1 ; a = more than one, decode dfkey12a:mov ah,byte ptr tranbuf ; get the single char mov byte ptr keycode,ah ; store as ascii keycode jmp dfkey1b ; go get definition dfkey13:push dx ; save command letters mov ah,cmeol ; get end of line confirmation call comnd pop dx jnc dfkey14 ; nc = success ret dfkey14:mov al,0ffh ; set DOS keyboard read flag cmp dx,'fo' ; first two letters of "off" je dfkey14a ; e = yes, use DOS keyboard calls xor al,al ; clear DOS keyboard read flag cmp dx,'no' ; first two letters of "on" je dfkey14a ; e = yes, use standard kbd calls mov ah,dosflg ; get current flag mov dosflg,1 ; engage for chk250 test push ax call chk250 ; see if LK250 driver is present pop ax mov al,ah ; recover current setting cmp got250,0 ; did we find the driver? je dfkey14a ; e = no call kbrest ; and activiate it if so mov al,1 ; say LK250 dfkey14a:mov dosflg,al ; store new keyboard flag ret dfkey15:mov ah,cmeol call comnd ; confirm request before proceeding jnc dfkeyc ; nc = success ret ; failure dfkey0: mov dx,offset dfhelp1 ; say bad definition command mov ah,prstr int dos stc ; failure ret dfkeyc: ; CLEAR key defs, restore startup defs mov cx,maxkeys ; size of keycode tables push es ; save register push ds pop es ; make es point to data segment xor ax,ax ; null, value to be stored mov di,offset dirlist ; director table cld rep stosw ; clear it mov cx,maxkeys mov di,offset keylist ; keycode table rep stosw ; clear it mov cx,maxstng mov di,offset sptable ; string pointer table rep stosw ; clear it pop es ; recover register mov strmax,offset stbuf ; clear string buffer, free space ptr mov stbuf,0 ; first element of buffer mov nkeys,0 ; clear number of defined keys call msuinit ; restore startup definitions clc ; success ret ; Multi-char key identification dfkey1: mov si,offset tranbuf ; point to key ident text cmp byte ptr [si],'0' ; is first character numeric? jb dfkey1a ; b = no cmp byte ptr [si],'9' ; in numbers? ja dfkey1a ; a = no mov keycode,scan ; setup keycode for scan value mov dx,si ; get length of string in cx call strlen push ds pop es ; make es point to data segment push si add si,cx ; point at string terminator mov di,si inc di ; place to store string (1 byte later) inc cx ; include null terminator std ; work backward rep movsb ; move string one place later cld pop si mov byte ptr [si],'\' ; make ascii digits into \nnn form mov oldform,0ffh ; set old form flag mov dx,offset kwarnmsg ; tell user this is old form mov ah,prstr int dos dfkey1a:call katoi ; convert ascii number to binary in ax jc dfkey0 ; c = no number converted or keycode,ax ; store in keycode dfkey1b: ; Get Definition proper test oldform,0ffh ; old form Set Key active? jz dfkey1f ; z = no mov bx,offset tranbuf ; get new definition on main cmd line mov word ptr [bx],0 ; insert terminator mov dx,offset dfhelp2 ; help for definition of key mov ah,cmline ; read rest of line into tranbuf call comnd ; allow null definitions or ax,ax ; char count zero? jz dfkey1e ; z = zero, prompt for definition jmp dfkey1g ; process definition dfkey1e:mov ah,prstr mov dx,offset crlf int dos mov dx,offset dfaskdf ; prompt for definition string call prompt ; Kermit prompt routine mov comand.cmcr,1 ; permit bare carriage returns mov comand.cmwhite,1 ; allow leading whitespace dfkey1f:mov bx,offset tranbuf ; get new definition mov word ptr [bx],0 ; insert terminator mov dx,offset dfhelp2 ; help for definition of key mov ah,cmline ; read rest of line into tranbuf call comnd jc dfkey1x ; exit now on ^C from user cmp comand.cmcr,0 ; prompting for definition? je dfkey1g ; e = no, trim leading whitespace mov comand.cmcr,0 ; turn off allowance for bare c/r's jmp dfkey2 ; interactive, allow leading whitespace dfkey1x:ret ; failure exit dfkey1g:push ax ; save count mov ah,cmeol ; get a confirm call comnd pop cx ; string length jc dfkey1x ; none so declare parse error dfkey2: ; Examine translation mov al,trans.escchr ; current escape char (port dependent) cmp al,byte ptr keycode ; is this Kermit's escape char? jne dfkey2a ; ne = no test keycode,scan ; see if scan code jnz dfkey2a ; nz = scan, so not ascii esc char mov dx,offset dfkoops ; Oops! msg mov ah,prstr ; complain and don't redefine int dos stc ; failure ret dfkey2a:push di ; get a director code for this key push cx mov di,offset keylist ; list of keycodes mov cx,nkeys ; number currently defined mov ax,keycode ; present keycode jcxz dfkey2b ; cx = 0 means none defined yet cld push ds pop es repne scasw ; is current keycode in the list? jne dfkey2b ; ne = not in list sub di,2 ; correct for auto increment sub di,offset keylist mov listptr,di ; list pointer for existing definition pop cx pop di jmp dfkey3 ; go process definition dfkey2b:pop cx ; key not currently defined so pop di ; make a new director entry for it mov bx,nkeys ; number of keys previously defined cmp bx,maxkeys ; enough space? jae dfkey2c ; ae = no, complain shl bx,1 ; count words mov listptr,bx ; index into word list mov ax,keycode ; get key's code mov keylist[bx],ax ; store it in list of keycodes mov dirlist[bx],0 ; clear the new director entry inc nkeys ; new number of keys jmp dfkey3 ; go process definition dfkey2c:mov dx,offset keyfull ; say key space is full already mov ah,prstr int dos stc ; failure ret ; listptr has element number in keylist or dirlist; keycode has key's code. ; Parse new definition. First look for Kermit verbs as a line beginning ; as \K or \{K. Otherwise, consider the line to be a string. ; In any case, update the Director table for the new definition. dfkey3: mov brace,0 ; assume not using braces mov si,offset tranbuf ; start of definition text cmp byte ptr [si],'\' ; starts with escape char? jne dfkey5 ; ne = no, so we have a string inc si ; skip the backslash cmp byte ptr [si],braceop ; starts with \{? jne dfkey3a ; ne = no inc si ; skip the opening brace mov brace,bracecl ; expect closing brace dfkey3a:cmp byte ptr [si],'K' ; starts with \{K or \K? je dfkey3b ; e = yes cmp byte ptr [si],'k' ; starts as \{k or \k? jne dfkey5 ; ne = no, then it's a string dfkey3b:inc si ; yes, skip the K too ; Kermit action VERBS push si ; save verb name start address dfkey4: cld lodsb ; scan til closing brace or w/s or end or al,al ; premature end? jz dfkey4b ; z = yes, accept without brace cmp al,brace ; closing brace? je dfkey4b ; e = yes cmp al,spc ; white space or control char? ja short dfkey4 ; a = no, so not at end yet dfkey4b:mov byte ptr[si-1],0 ; insert null terminator pop si ; recover start address call tstkeyw ; find keyword, kw # returned in kbtemp jc dfkey4d ; c = no keyword found, complain call remstr ; clear old string, if string mov ax,kbtemp ; save keyword number and ax,not(verb+strng) ; clear verb / string field or ax,verb ; set verb ident mov si,listptr mov dirlist[si],ax ; store info in Director table jmp dfkey7 ; show results and return success dfkey4d:mov dx,offset verbbad ; say no such verb mov ah,prstr int dos stc ; failure ret ; Here we are left with the definition string; si points to its start, and ; kbtemp holds its length (number of bytes). Null termination. If the string ; begins with an opening brace it terminates on a matching closing brace ; or the end of line, whichever occurs first. Trailing whitespace removed ; before examining braces. ; Null length strings mean define key as Self. ; STRING definitions dfkey5: call remstr ; first, clear old string, if any mov si,offset tranbuf ; si=source, di=dest, convert in-place mov di,si call cnvlin ; convert numbers, cx gets line length mov si,offset tranbuf ; provide address of new string cmp cx,1 ; just zero or one byte to do? jbe dfkey6 ; e = yes, do as a char call insertst ; insert new string, returns reg cx. jc dfkey5h ; c = could not do insert mov si,listptr ; cx has type and string number mov dirlist[si],cx ; update Director table from insertst jmp dfkey7 ; show results and return success dfkey5h:mov dx,offset strbad ; display complaint mov ah,prstr int dos stc ; failure ret ; define SINGLE CHAR replacement or CLEAR a key definition. ; cx has char count 1 (normal) or 0 (to undefine the key). dfkey6: jcxz dfkey6c ; z = cx= 0, clear definition mov al,byte ptr [si] ; get first byte from definition xor ah,ah ; set the type bits to Char mov si,listptr mov dirlist[si],ax ; store type and key's new code jmp dfkey7 ; return success dfkey6c:push si ; clear a definition, push di ; listptr points to current def mov si,listptr ; starting address to clear add si,offset dirlist mov di,si ; destination add si,2 ; source is next word mov cx,nkeys ; current number of keys defined add cx,cx ; double for listptr being words sub cx,listptr ; cx = number of words to move shr cx,1 ; convert to actual number of moves jcxz dfkey6d ; z = none, just remove last word push es push ds pop es ; make es:di point to data segment cld push cx ; save cx rep movsw ; move down higher list items pop cx mov si,listptr ; do keylist too, same way add si,offset keylist mov di,si add si,2 rep movsw pop es dfkey6d:mov si,nkeys ; clear old highest list element shl si,1 ; address words mov dirlist[si],0 ; null the element mov keylist[si],0 ; null the element dec nkeys ; say one less key defined now pop di ; restore saved registers pop si dfkey7: mov ah,msutake ; Finish up. In a Take file? or ah,taklev ; or even directly or ah,ah jz dfkey7a ; z = no cmp flags.takflg,0 ; echo Take commands? je dfkey7b ; e = no dfkey7a:mov ah,prstr ; display cr/lf mov dx,offset crlf int dos call shkey0 ; show new definition (in SHKEY) call shkfre ; show free string space dfkey7b:clc ; return success ret DFKEY ENDP ; SHOW KEY <cr> command. Call from Kermit level. Vectored here by SHOW ; command. Replaces obsolete procedure in msx---. ; Prompts for a key and shows that key's (or all if ? entered) keycode, ; definition, and the key definition free space remaining. SHKEY PROC NEAR ; Show key's definition command mov ah,cmeol ; get a confirm call comnd ; ignore any additional text push bx mov dx,offset shkmsg1 ; ask for original key mov ah,prstr int dos or byte ptr kbcodes,80h ; say kbcodes not-initiated shky0: call getkey ; read keyboard, output to keycode jc shky0 ; wait for a key (c = nothing there) cmp byte ptr keycode,'?' ; query for all keys? jne shky0a ; ne = no, not a query test keycode,scan ; is this a scan code, vs ascii query? jz shky0c ; z = no Scan, so it is a query shky0a: mov ah,prstr ; show single key. Setup display mov dx,offset crlf int dos call shkey0 ; show just one key shky0b: call shkfre ; show free string space jmp shkeyx ; exit shky0c: mov cx,nkeys ; Show all keys. nkeys = number defined jcxz shky0b ; z = none to show mov si,offset keylist ; list of definitions push si ; save pointer shky1: pop si ; recover pointer cld lodsw ; get a keycode push si ; save pointer push cx ; save counter mov keycode,ax ; save new keycode mov ah,prstr mov dx,offset crlf int dos call shkey0 ; show this keycode pop cx ; pause between screens, recover cntr push cx ; save it again dec cx ; number yet to be shown jcxz shky1b ; z = have now shown all of them mov ax,nkeys ; number of defined keys sub ax,cx ; minus number yet to be displayed xor dx,dx ; clear extended numerator div twelve ; two lines per definition display or dx,dx ; remainder zero (12 defs shown)? jnz shky1b ; nz = no, not yet so keep going mov ah,prstr mov dx,offset shkmsg3 ; "push any key to continue" msg int dos shky1a: mov ah,0bh ; check console, check ^C int dos cmp flags.cxzflg,'C' ; a ^C? je shky1b ; e = yes, quit or al,al jz shky1a ; z = nothing call getkey ; get any key jc shky1a ; c = nothing at keyboard yet, wait shky1b: pop cx ; resume loop cmp flags.cxzflg,'C' ; a ^C? je shky1c ; e = yes, quit loop shky1 shky1c: pop si ; clean stack call shkfre ; show free string space jmp shkeyx ; exit ; show key worker routine, called from above ; SHKEY0 called by DFKEY just above SHKEY0: test keycode,scan ; scan code? jz shkey1 ; z = no, regular ascii ; SCAN codes mov dx,offset scanmsg ; say Scan Code: mov ah,prstr int dos mov ah,conout mov dl,'\' ; add backslash before number int dos mov ax,keycode ; get key's code again call decout ; display 16 bit decimal keycode jmp shkey2 ; go get definition shkey1: mov dx,offset ascmsg ; say ASCII CHAR mov ah,prstr int dos mov dl,byte ptr keycode ; get ascii code (al part of input) mov ah,conout cmp dl,spc ; control code? jae shkey1a ; ae = no push dx ; save char mov dl,5eh ; show caret first int dos pop dx add dl,'A'-1 ; ascii bias shkey1a:cmp dl,del ; DEL? jne shkey1b ; ne = no mov dl,'D' ; spell out DEL int dos mov dl,'E' int dos mov dl,'L' shkey1b:int dos mov dl,spc ; add a couple of spaces int dos int dos mov dl,'\' ; add backslash before number int dos mov ax,keycode ; show 16 bit keycode in decimal call decout ; and go get definiton ; Display defintion shkey2: mov dx,offset shkmsg2 ; intermediate part of reply mov ah,prstr ; " is defined as " int dos push di ; get a director code for this key push cx mov di,offset keylist ; list of keycodes mov cx,nkeys ; number currently defined jcxz shkey2a ; z = none mov ax,keycode ; present keycode push ds pop es ; use data segment for es:di cld repne scasw ; is current keycode in the list? jne shkey2a ; ne = not in list sub di,2 ; correct for auto increment sub di,offset keylist mov listptr,di ; list pointer for existing definition pop cx pop di jmp shkey3 ; go process definition shkey2a:pop cx pop di mov dx,offset noxmsg ; say Self (no translation) mov ah,prstr int dos ret ; return to main show key loop shkey3: ; translations, get kind of. mov si,listptr test dirlist[si],verb ; defined as verb? jnz shkey6 ; nz = yes, go do that one test dirlist[si],strng ; defined as string? jz shkey3a ; z = no jmp shkey8 ; yes, do string display shkey3a: mov dx,offset ascmsg ; CHAR. say 'Ascii char:' mov ah,prstr int dos mov ax,dirlist [si] ; get type and char mov dl,al ; put char here for display push ax ; save here too mov ah,conout cmp dl,spc ; control code? jae shkey4 ; ae = no push dx mov dl,5eh ; show caret int dos pop dx add dl,'A'-1 ; add ascii bias shkey4: cmp dl,del ; DEL? jne shkey4a ; ne = no mov dl,'D' ; spell out DEL int dos mov dl,'E' int dos mov dl,'L' shkey4a:int dos mov dl,spc ; add a couple of spaces mov ah,conout int dos int dos mov dl,'\' ; add backslash before number int dos pop ax ; recover char xor ah,ah ; clear high byte call decout ; show decimal value ret ; return to main show key loop shkey6: mov ah,prstr ; VERB mov dx,offset verbmsg ; say 'verb' int dos mov si,listptr ; get verb index from director mov dx,dirlist[si] and dx,not(verb+strng) ; remove type bits, leaves verb number mov bx,offset kverbs ; table of verbs & actions mov al,byte ptr [bx] ; number of keywords xor ah,ah dec ax mov kwcnt,ax ; save number of last one here cmp dx,ax ; asking for more than we have? ja shkeyx ; a = yes, exit bad inc bx ; point to first slot xor cx,cx ; current slot number shkey6b:cmp cx,dx ; this slot? je shkey6c ; e = yes, print the text part ja shkeyx ; a = beyond, exit bad mov ax,[bx] ; get cnt (keyword length) add ax,4 ; skip count and two byte value add bx,ax ; bx = start of next keyword slot inc cx ; current keyword number jmp short shkey6b ; try another shkey6c:push cx mov cx,[bx] ; length of definition add bx,2 ; look at text field mov di,bx ; offset for printing call prtscr ; print counted string mov ah,conout mov dl,spc ; add a couple of spaces int dos int dos mov dl,'\' ; show verb name as \Kverb int dos mov dl,'K' int dos call prtscr ; print counted string, again pop cx ret ; return to main show key loop shkey8: mov ah,prstr ; STRING mov dx,offset strngmsg ; say String: int dos mov si,listptr ; get index from director mov bx,dirlist[si] and bx,not(verb+strng) ; remove type bits shl bx,1 ; index words mov si,sptable[bx] ; table of string offsets mov cx,word ptr [si] ; get string length add si,2 ; point to string text mov ah,conout shkey8a:cld lodsb ; get a byte cmp al,127 ; DEL? je shkey8c ; e = yes cmp al,spc ; control code? jae shkey8b ; ae = no shkey8c:push ax mov dl,5eh ; show caret first int dos pop ax add al,40h ; convert to printable for display and al,7fh shkey8b:mov dl,al int dos ; display it loop shkey8a ; do another ret ; return to main show key loop shkeyx: pop bx ; restore reg clc ; return success ret SHKEY ENDP ;;; keyboard translator local support procedures, system independent ; Tstkeyw checks text word pointed to by si against table of keywords (pointed ; to by kverbs, made by mkeyw macro); returns in bx either action value or 0. ; Returns in kbtemp the number of the keyword and carry clear, or if failure ; returns kbtemp zero and carry set. ; Keyword structure is: dw cnt (length of string 'word') ; db 'word' (keyword string) ; dw value (value returned in bx) ; Make these with macro mkeyw such as mkeyw 'test',15 with the list of ; such keywords headed by a byte giving the number of keywords in the list. tstkeyw proc near push ax push cx push si mov verblen,0 ; verblen will hold verb length push si ; save user's verb pointer tstkw1: cld lodsb ; get a verb character cmp al,spc ; verbs are all non-spaces and above jbe tstkw2 ; be = done (space or control char) inc verblen ; count verb length jmp short tstkw1 ; printable char, look for more tstkw2: pop si ; pointer to verb mov bx,offset kverbs ; table of Kermit verb keywords mov al,byte ptr [bx] ; number of keywords xor ah,ah mov kwcnt,ax ; save number of keywords here inc bx ; point bx to first slot mov kbtemp,0 ; remember which keyword tstkw3: ; match table keyword and text word mov cx,verblen ; length of user's verb cmp [bx],cx ; compare length vs table keyword jne tstkw4 ; ne = not equal lengths, try another push si ; lengths match, how about spelling? push bx add bx,2 ; point at start of keyword tstkw3a:mov ah,byte ptr [bx] ; keyword char mov al,byte ptr [si] ; text char cmp ah,'A' jb tstkw3b ; b = control chars cmp ah,'Z' ja tstkw3b ; a = not upper case alpha add ah,'a'-'A' ; convert upper case to lower case tstkw3b:cmp al,'A' jb tstkw3c cmp al,'Z' ja tstkw3c add al,'a'-'A' ; convert upper case to lower case tstkw3c:cmp al,ah ; test characters jne tstkw3d ; ne = no match inc si ; move to next char inc bx loop tstkw3a ; loop through entire length tstkw3d:pop bx pop si jcxz tstkw5 ; z: cx = 0, exit with match; ; else select next keyword tstkw4: inc kbtemp ; number of keyword to test next mov cx,kbtemp cmp cx,kwcnt ; all done? Recall kbtemp starts at 0 jae tstkwx ;ae = exhausted search, unsuccessfully mov ax,[bx] ; cnt (keyword length from macro) add ax,4 ; skip over count and two byte value add bx,ax ; bx = start of next keyword slot jmp tstkw3 ; do another comparison tstkw5: ; get action pointer mov ax,[bx] ; cnt (keyword length from macro) add ax,2 ; skip over count add bx,ax ; now bx points to dispatch value mov bx,[bx] ; bx holds dispatch value clc ; carry clear for success jmp short tstkwxx ; exit ret tstkwx: xor bx,bx ; exit when no match mov kbtemp,bx ; make verb number be zero too stc ; carry set for failure tstkwxx:pop si pop cx pop ax ret tstkeyw endp ; Insert asciiz string pointed to by si into string buffer stbuf. ; Reg cx has string length upon entry. ; Success: returns offset of first free byte (strmax) in string buffer stbuf, ; cx = type and Index of new string, and carry clear. ; Failure = carry set. insertst proc near push bx push dx push si push di push kbtemp ; save this variable too mov dx,cx ; save length of incoming string in dx mov bx,offset sptable ; table of string offsets mov kbtemp,0 ; slot number mov cx,maxstng ; number of entries, find an empty slot insert1:cmp word ptr[bx],0 ; slot empty? je insert2 ; e = yes inc kbtemp ; remember slot number add bx,2 ; look at next slot loop insert1 ; keep looking jmp short insert4 ; get here if no empty slots insert2: ; see if stbuf has sufficient space mov cx,dx ; length of new string to cx mov di,strmax ; offset of first free byte in stbuf add di,cx ; di = address where this string would end cmp di,offset stbuf+stbuflen ; beyond end of buffer? jae insert4 ; ae = yes, not enough room mov di,strmax ; point to first free slot in stbuf mov [bx],di ; fill slot with address offset of buffer push es push ds pop es ; point es:di to data segment cld mov [di],cx ; length of text for new string add di,2 ; move to next storage slot rep movsb ; copy string text pop es mov strmax,di ; offset of next free byte mov cx,kbtemp ; return new slot number with Director Index and cx,not(strng+verb) ; clear type bits or cx,strng ; say type is multi-char string clc ; say success jmp short insertx ; exit insert4:stc ; say no-can-do insertx:pop kbtemp pop di pop si pop dx pop bx ret insertst endp ; Remove (delete) string. Enter with listptr preset for director entry. ; Acts only on existing multi-char strings; recovers freed space. ; All registers preserved. remstr proc near push si mov si,listptr ; list pointer test dirlist[si],strng ; multi-char string? pop si jnz remst1 ; nz = a multi-char string ret ; else do nothing remst1: push ax push bx push cx push dx push si mov si,listptr mov ax,dirlist[si] ; Director table entry and ax,not(strng+verb) ; clear type bits, leave string's pointer mov dirlist[si],0 ; clear Director table entry shl ax,1 ; index words not bytes mov si,offset sptable ; list of string offsets in stbuf add si,ax ; plus index = current slot mov bx,[si] ; get offset of string to be deleted mov dx,bx ; save in dx for later mov cx,[bx] ; get length of subject string add cx,2 ; length word too, cx has whole length sub strmax,cx ; count space to be freed (adj end-of-buf ptr) mov word ptr [si],0 ; clear sptable of subject string address push cx ; save length of purged string push di ; save di push si push es ; save es push ds pop es ; setup es:di to be ds:offset of string mov di,dx ; destination = start address of purged string mov si,dx ; source = start address of purged string add si,cx ; plus string length of purged string. mov cx,offset stbuf+stbuflen ; 1 + address of buffer end sub cx,si ; 1 + number of bytes to move dec cx ; number of bytes to move jcxz remst2 ; z = none cld ; direction is forward rep movsb ; move down preserved strings remst2: pop es ; restore regs pop di pop si pop ax ; recover length of purged string (was in cx) mov bx,offset sptable ; string pointer table mov cx,maxstng ; max mumber of entries remst4: cmp [bx],dx ; does this entry occur before purged string? jbe remst5 ; be = before or equal, so leave it alone sub [bx],ax ; recompute address (remove old string space) remst5: add bx,2 ; look at next list entry loop remst4 ; do all entries in sptable pop si pop dx pop cx pop bx pop ax ret remstr endp shkfre proc near ; show free key & string defs & space push ax ; preserves all registers. push bx push cx push dx push kbtemp mov dx,offset fremsg mov ah,prstr int dos mov ax,maxkeys ; max number of key defs sub ax,nkeys ; number currently used call decout ; show the value mov ah,prstr mov dx,offset kyfrdef ; give key defs msg int dos mov bx,offset sptable ; table of string pointers mov cx,maxstng ; number of pointers mov kbtemp,0 ; number free shkfr1: cmp word ptr [bx],0 ; slot empty? jne shkfr2 ; ne = no inc kbtemp ; count free defs shkfr2: add bx,2 ; look at next slot loop shkfr1 ; do all of them mov ax,kbtemp ; number of free defs call decout ; display mov dx,offset stfrdef ; say free string defs mov ah,prstr int dos mov ax,offset stbuf+stbuflen+1 ; 1 + last byte in stbuf sub ax,strmax ; offset of last free byte in stbuf call decout mov dx,offset stfrspc ; give free space part of msg mov ah,prstr int dos pop kbtemp pop dx pop cx pop bx pop ax ret shkfre endp ; Initialize the keyboard tables at Kermit startup time. Optional procedure. ; Requires kbdinlst to be configured with mkeyw macro in the form ; mkeyw 'definition',keytype*256+keycode ; keytype is 0 for scan codes and non-zero for ascii. ; Returns normally. kbdinit proc near ; read keyword kbdinlst and setup or byte ptr kbcodes,80h ; say kbcodes not-initiated push ds ; initial keyboard assignments. pop es ; set es:di to data segment inc taklev ; pretend that we are in Take file call chk250 ;** LK250 support begin cmp got250,1 ;** is it installed? jne kbdini0 ;** ne = no call kbrest ;** else initialize to DEC mode mov si,offset kb250lst ;** load extensions jmp short kbdini1 ;** LK250 support end kbdini0:mov si,offset kbdinlst ; start of list of definitions kbdini1:mov cx,[si] ; cnt field (keyword length of macro) jcxz kbdinix ; z = null cnt field = end of list add si,2 ; look at text field mov di,offset tranbuf ; where defkey expects text cld rep movsb ; copy cx chars to tranbuf mov byte ptr [di],0 ; insert null terminator mov ax,word ptr [si] ; get value field mov keycode,ax ; set key ident value push si call dfkey2 ; put dfkey to work pop si add si,2 ; point to next entry jmp kbdini1 ; keep working kbdinix:dec taklev ; reset Take file level call fudkclear ; clear User Definable Keys mov cx,40h ; segment 40h mov es,cx mov cl,byte ptr es:[96h] ; kbd_flag_3, Enhanced keyboard area test cl,10h ; select Enhanced kbd presence bit jz kbdinx1 ; z = regular (88) mov keyboard,101 ; 101 = enhanced kbd kbdinx1:ret kbdinit endp ;;; End of System Independent Procedures ;;; Begin System Dependent Procedures ; Read keyboard. System dependent. ; Return carry set if nothing at keyboard. ; If char present return carry clear with key's code in Keycode. ; If key is ascii put that in the low byte of Keycode and clear bit Scan in ; the high byte; otherwise, put the scan code in the lower byte and set bit ; Scan in the high byte. ; Bit Scan is set if key is not an ascii code. ; Two methods are used: Bios reading for Set Key ON, and DOS reading for ; Set Key OFF. DOS scan codes are coerced to Bios values as much as possible. ; Modifies register ax. getkey proc near mov keycode,0 ; clear old keycode cmp dosflg,0ffh ; do DOS keyboard reading? je getky7 ; e = yes, DOS jmp getky6 ; do full Bios form ; ;;;;;;;; D O S ;;;;;;;;;; getky7: test byte ptr kbcodes,80h ; kbcodes initiated? [dan] jz getky5 ; z = yes [dan] and byte ptr kbcodes,not 80h ; say kbcodes initiated getky5: call iseof ; is stdin at eof? jnc getky5k ; nc = not eof, get more mov al,trans.escchr ; Kermit's escape char mov byte ptr keycode,al ; save ascii char clc ; to get out gracefully at EOF ret ; and exit getky5k:mov dl,0ffh ; DOS read operation mov ah,dconio ; from stdin int dos jnz getky5a ; nz = char available stc ; carry set = nothing available ret ; exit on no char getky5a:or al,al ; scan code precursor? jz getky5d ; z = yes cmp al,16 ; Control P? jne getky5b ; ne = no mov al,114 ; force Control PrtSc scan code jmp short getky5e ; process as scan code getky5b:cmp al,BS ; backspace key? jne getky5c ; ne = no mov al,14 ; force scan code for BS key jmp short getky5e ; process as scan code getky5c:mov byte ptr keycode,al ; save ascii char clc ; carry clear = got a char ret ; and exit getky5d:mov dl,0ffh ; read second byte (actual scan code) mov ah,dconio ; read via DOS int dos jnz getky5e ; nz = got a char stc ; none, declare bad read ret ; Check and modify to Bios scan codes getky5e:mov byte ptr keycode,al ; save char code cmp al,1 ; Alt escape je getkya ; set Alt bit cmp al,16 ; back tab jb getky5g ; these remain unchanged cmp al,50 ; start of meta keys jb getkya ; b = set Alt bit cmp al,84 ; Shift F1 jb getky5g ; b = no change cmp al,94 ; Control F1 jb getkys ; set Shift bit cmp al,104 ; Alt F1 jb getkyc ; set Control bit cmp al,114 ; Control PrtSc jb getkya ; set Alt bit cmp al,120 ; Alt top rank jb getkyc ; set Control bit cmp al,132 ; Control PgUp jb getkya ; set Alt bit je getkyc ; set Control bit cmp al,135 ; Shift F11, for Enhanced keyboard jb getky5g ; no change cmp al,137 ; Control F11 jb getkys ; set Shift bit cmp al,139 ; Alt F11 jb getky5c ; set Control bit cmp al,141 ; Control Up jb getkya ; set Alt bit cmp al,151 ; Alt Home jb getkyc ; set Control bit jmp short getkya ; set Alt bit getkyc: or keycode,control ; set Control bit jmp short getky5g getkys: or keycode,shift ; set Shift bit jmp short getky5g getkya: or keycode,alt ; set Alt bit getky5g:or keycode,scan ; ensure scan bit is set clc ; report we have a scan keycode ret ; and exit ; ;;;;;;;;;; B I O S ;;;;;;;;;;;;; getky6: ; full BIOS keyboard reading test byte ptr kbcodes,80h ; kbcodes initiated? [dan] jz getky6a ; z = yes [dan] mov kbcodes,0001h ; low byte = status, high = read char push cx ; save registers push es mov cx,40h ; segment 40h mov es,cx mov cl,byte ptr es:[96h] ; kbd_flag_3, Enhanced keyboard area and cl,10h ; select Enhanced kbd presence bit mov ch,cl ; copy, for both status and read or kbcodes,cx ; 0 = regular kbd, 10h = enhanced kbd pop es pop cx getky6a:mov ah,byte ptr kbcodes ; anything at keyboard? xor al,al int kbint ; Bios keyboard interrupt jnz getky1 ; nz = char available cmp ax,240 ; Bios "special ascii code" 0f0h? je getky1 ; e = yes, Bios makes error, is a key stc ; carry set = nothing available ret ; exit on no char available getky1: mov ah,byte ptr kbcodes+1 ; read, no echo, wait til done int kbint ; ==> ah = scan code, al = char value cmp ah,0 ; keycode entered by ALT ###? je getky1c ; e = yes, not enhanced cmp ah,0e0h ; Enhanced kbd Enter, fwd slash keys? jne getky1b ; ne = no xchg ah,al ; interchange scan and ascii fields getky1b:cmp al,0E0h ; enhanced key hidden code? jne getky1c ; ne = no mov byte ptr keycode,ah ; retain scan code, surpress 0e0h or keycode,scan+enhanced ; set scan and enhanced idents mov ah,2 ; use regular keyboard op code here int kbint ; get current shift state mov bl,al ; copy for a moment and bl,rgt_shift ; mask out all but right shift shl bl,1 ; move right shift to left shift pos or al,bl ; collapse shift bits and al,(lft_shift + alt_shift + ctl_shift) or byte ptr keycode+1,al ; store in type field of keycode clc ; say have a keystroke jmp getkyx ; Enhanced kbd end. Skip other tests getky1c:push cx mov cx,aliaslen ; number of aliased keys or cx,cx pop cx jz getky2 ; z = none push di ; check key (ax) for aliases push cx push es push ds pop es ; make es:di refer to data segment mov di,offset aliaskey ; list of aliased keys mov cx,aliaslen ; number of entries cld repne scasw ; look for a match pop es pop cx pop di jne getky2 ; ne = not there xor al,al ; force use of scan code (in ah) getky2: or al,al ; scan code being returned? jnz getky3 ; nz = no mov byte ptr keycode,ah ; store scan code for gsh push ax push bx call gsh ; get modified shift state or byte ptr keycode+1,al ; store in type field of keycode pop bx pop ax xchg ah,al ; put scan code in al or keycode,scan ; set scan flag (vs ascii) getky3: mov byte ptr keycode,al ; return key's code (usually ascii) clc ; carry clear = got a char getkyx: ret getkey endp ; get shift state into al. We care about only shift, ctl, and alt keys. ; right shift is collapsed into left shift. NumLock offsets Shift on keypad ; white keys. gsh proc near mov ah,2 int kbint ; get current shift state mov bl,al ; copy for a moment and bl,rgt_shift ; mask out all but right shift shl bl,1 ; move right shift to left shift pos or al,bl ; collapse shift bits cmp byte ptr keycode,71 ; below numeric key pad? jb gsh1 ; b = yes cmp byte ptr keycode,83 ; above numeric key pad? ja gsh1 ; a = yes cmp byte ptr keycode,74 ; grey - key ? je gsh1 ; e = yes cmp byte ptr keycode,78 ; grey + key je gsh1 ; e = yes test al,numlock ; numlock set? jz gsh1 ; z = no xor al,lft_shift ; numlock offsets shift and vice versa gsh1: and al,(lft_shift + alt_shift + ctl_shift) ret gsh endp ; Do any local processing after reading a key during active translation ; Avoids same actions if a key is being defined or shown. postkey proc near ; Key Click code for VT102 emulator cmp flags.vtflg,0 ; emulating? (0 = no) je postke1 ; e = extra clicks not available test vtemu.vtflgst,vskeyclick ; flags from SET TERM jz postke1 ; z = extra clicks not wanted call fvclick ; click, what else? postke1:ret postkey endp ;** start of LK250 stuff chk250 proc near ; presence test for DEC LK250 keyboard mov got250,0 ; assume no LK250 keyboard cmp dosflg,1 ; use LK250? jne chk250x ; ne = no mov ax,sp ; do push sp test for XT vs AT/386 push sp ; XT pushes sp-2, AT's push old sp pop cx ; recover pushed value, clean stack xor ax,cx ; same? jne chk250a ; ne = no, XT. Don't do Int 15h mov ax,5000h ; see if the keyboard is loaded int 15h ; look for DOS->DEC mode driver cmp ax,1234h ; find marker 1234h jne chk250a ; ne = marker not present, no driver mov got250,1 ; else say we have an LK250 mov keyboard,250 ; global Variable chk250x:ret chk250a:mov ah,prstr mov dx,offset lk250msg ; say driver not active int dos ret chk250 endp kbrest proc near ; set LK250 to DEC mode cmp got250,1 ; LK250 present? jne kbrest1 ; ne = no push es ; save reg mov ax,40h ; point to low memory mov es,ax or byte ptr es:[17h],20h ; ensure Num Lock is on and byte ptr es:[17h],0efh ; and Scroll is off pop es ; restore our [DS] mov ax,5001h ; issue set mode DEC to keyboard int 15h kbrest1:ret kbrest endp kbsusp proc near ; set LK250 to DOS mode cmp got250,1 ; LK250 present? jne kbsusp1 ; ne = no mov ax,5000h ; unload extensions int 15h kbsusp1:ret kbsusp endp kbhold proc near cmp got250,1 ; LK250 present? jne kbhold1 ; ne = no mov ax,5002h ; issue SET LEDS mov bl,0edh int 15h mov ax,5002h mov bl,holdscr ; get the hold state or bl,2 ; OR in Num Lock int 15h kbhold1:ret kbhold endp ;** end of LK250 stuff code ends end